home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / urllib.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  45KB  |  1,664 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Open an arbitrary URL.
  5.  
  6. See the following document for more info on URLs:
  7. "Names and Addresses, URIs, URLs, URNs, URCs", at
  8. http://www.w3.org/pub/WWW/Addressing/Overview.html
  9.  
  10. See also the HTTP spec (from which the error codes are derived):
  11. "HTTP - Hypertext Transfer Protocol", at
  12. http://www.w3.org/pub/WWW/Protocols/
  13.  
  14. Related standards and specs:
  15. - RFC1808: the "relative URL" spec. (authoritative status)
  16. - RFC1738 - the "URL standard". (authoritative status)
  17. - RFC1630 - the "URI spec". (informational status)
  18.  
  19. The object returned by URLopener().open(file) will differ per
  20. protocol.  All you know is that is has methods read(), readline(),
  21. readlines(), fileno(), close() and info().  The read*(), fileno()
  22. and close() methods work like those of open files.
  23. The info() method returns a mimetools.Message object which can be
  24. used to query various info about the object, if available.
  25. (mimetools.Message objects are queried with the getheader() method.)
  26. '''
  27. import string
  28. import socket
  29. import os
  30. import time
  31. import sys
  32. from urlparse import urljoin as basejoin
  33. __all__ = [
  34.     'urlopen',
  35.     'URLopener',
  36.     'FancyURLopener',
  37.     'urlretrieve',
  38.     'urlcleanup',
  39.     'quote',
  40.     'quote_plus',
  41.     'unquote',
  42.     'unquote_plus',
  43.     'urlencode',
  44.     'url2pathname',
  45.     'pathname2url',
  46.     'splittag',
  47.     'localhost',
  48.     'thishost',
  49.     'ftperrors',
  50.     'basejoin',
  51.     'unwrap',
  52.     'splittype',
  53.     'splithost',
  54.     'splituser',
  55.     'splitpasswd',
  56.     'splitport',
  57.     'splitnport',
  58.     'splitquery',
  59.     'splitattr',
  60.     'splitvalue',
  61.     'splitgophertype',
  62.     'getproxies']
  63. __version__ = '1.16'
  64. MAXFTPCACHE = 10
  65. if os.name == 'mac':
  66.     from macurl2path import url2pathname, pathname2url
  67. elif os.name == 'nt':
  68.     from nturl2path import url2pathname, pathname2url
  69. elif os.name == 'riscos':
  70.     from rourl2path import url2pathname, pathname2url
  71. else:
  72.     
  73.     def url2pathname(pathname):
  74.         return unquote(pathname)
  75.  
  76.     
  77.     def pathname2url(pathname):
  78.         return quote(pathname)
  79.  
  80. _urlopener = None
  81.  
  82. def urlopen(url, data = None, proxies = None):
  83.     '''urlopen(url [, data]) -> open file-like object'''
  84.     global _urlopener
  85.     if proxies is not None:
  86.         opener = FancyURLopener(proxies = proxies)
  87.     elif not _urlopener:
  88.         opener = FancyURLopener()
  89.         _urlopener = opener
  90.     else:
  91.         opener = _urlopener
  92.     if data is None:
  93.         return opener.open(url)
  94.     else:
  95.         return opener.open(url, data)
  96.  
  97.  
  98. def urlretrieve(url, filename = None, reporthook = None, data = None):
  99.     global _urlopener
  100.     if not _urlopener:
  101.         _urlopener = FancyURLopener()
  102.     
  103.     return _urlopener.retrieve(url, filename, reporthook, data)
  104.  
  105.  
  106. def urlcleanup():
  107.     if _urlopener:
  108.         _urlopener.cleanup()
  109.     
  110.  
  111.  
  112. class ContentTooShortError(IOError):
  113.     
  114.     def __init__(self, message, content):
  115.         IOError.__init__(self, message)
  116.         self.content = content
  117.  
  118.  
  119. ftpcache = { }
  120.  
  121. class URLopener:
  122.     """Class to open URLs.
  123.     This is a class rather than just a subroutine because we may need
  124.     more than one set of global protocol-specific options.
  125.     Note -- this is a base class for those who don't want the
  126.     automatic handling of errors type 302 (relocated) and 401
  127.     (authorization needed)."""
  128.     __tempfiles = None
  129.     version = 'Python-urllib/%s' % __version__
  130.     
  131.     def __init__(self, proxies = None, **x509):
  132.         if proxies is None:
  133.             proxies = getproxies()
  134.         
  135.         if not hasattr(proxies, 'has_key'):
  136.             raise AssertionError, 'proxies must be a mapping'
  137.         self.proxies = proxies
  138.         self.key_file = x509.get('key_file')
  139.         self.cert_file = x509.get('cert_file')
  140.         self.addheaders = [
  141.             ('User-agent', self.version)]
  142.         self._URLopener__tempfiles = []
  143.         self._URLopener__unlink = os.unlink
  144.         self.tempcache = None
  145.         self.ftpcache = ftpcache
  146.  
  147.     
  148.     def __del__(self):
  149.         self.close()
  150.  
  151.     
  152.     def close(self):
  153.         self.cleanup()
  154.  
  155.     
  156.     def cleanup(self):
  157.         if self._URLopener__tempfiles:
  158.             for file in self._URLopener__tempfiles:
  159.                 
  160.                 try:
  161.                     self._URLopener__unlink(file)
  162.                 continue
  163.                 except OSError:
  164.                     continue
  165.                 
  166.  
  167.             
  168.             del self._URLopener__tempfiles[:]
  169.         
  170.         if self.tempcache:
  171.             self.tempcache.clear()
  172.         
  173.  
  174.     
  175.     def addheader(self, *args):
  176.         """Add a header to be used by the HTTP interface only
  177.         e.g. u.addheader('Accept', 'sound/basic')"""
  178.         self.addheaders.append(args)
  179.  
  180.     
  181.     def open(self, fullurl, data = None):
  182.         """Use URLopener().open(file) instead of open(file, 'r')."""
  183.         fullurl = unwrap(toBytes(fullurl))
  184.         if self.tempcache and fullurl in self.tempcache:
  185.             (filename, headers) = self.tempcache[fullurl]
  186.             fp = open(filename, 'rb')
  187.             return addinfourl(fp, headers, fullurl)
  188.         
  189.         (urltype, url) = splittype(fullurl)
  190.         if not urltype:
  191.             urltype = 'file'
  192.         
  193.         if urltype in self.proxies:
  194.             proxy = self.proxies[urltype]
  195.             (urltype, proxyhost) = splittype(proxy)
  196.             (host, selector) = splithost(proxyhost)
  197.             url = (host, fullurl)
  198.         else:
  199.             proxy = None
  200.         name = 'open_' + urltype
  201.         self.type = urltype
  202.         name = name.replace('-', '_')
  203.         if not hasattr(self, name):
  204.             if proxy:
  205.                 return self.open_unknown_proxy(proxy, fullurl, data)
  206.             else:
  207.                 return self.open_unknown(fullurl, data)
  208.         
  209.         
  210.         try:
  211.             if data is None:
  212.                 return getattr(self, name)(url)
  213.             else:
  214.                 return getattr(self, name)(url, data)
  215.         except socket.error:
  216.             msg = None
  217.             raise IOError, ('socket error', msg), sys.exc_info()[2]
  218.  
  219.  
  220.     
  221.     def open_unknown(self, fullurl, data = None):
  222.         '''Overridable interface to open unknown URL type.'''
  223.         (type, url) = splittype(fullurl)
  224.         raise IOError, ('url error', 'unknown url type', type)
  225.  
  226.     
  227.     def open_unknown_proxy(self, proxy, fullurl, data = None):
  228.         '''Overridable interface to open unknown URL type.'''
  229.         (type, url) = splittype(fullurl)
  230.         raise IOError, ('url error', 'invalid proxy for %s' % type, proxy)
  231.  
  232.     
  233.     def retrieve(self, url, filename = None, reporthook = None, data = None):
  234.         '''retrieve(url) returns (filename, headers) for a local object
  235.         or (tempfilename, headers) for a remote object.'''
  236.         url = unwrap(toBytes(url))
  237.         if self.tempcache and url in self.tempcache:
  238.             return self.tempcache[url]
  239.         
  240.         (type, url1) = splittype(url)
  241.         if filename is None:
  242.             if not type or type == 'file':
  243.                 
  244.                 try:
  245.                     fp = self.open_local_file(url1)
  246.                     hdrs = fp.info()
  247.                     del fp
  248.                     return (url2pathname(splithost(url1)[1]), hdrs)
  249.                 except IOError:
  250.                     msg = None
  251.                 except:
  252.                     None<EXCEPTION MATCH>IOError
  253.                 
  254.  
  255.         None<EXCEPTION MATCH>IOError
  256.         fp = self.open(url, data)
  257.         headers = fp.info()
  258.         if filename:
  259.             tfp = open(filename, 'wb')
  260.         else:
  261.             import tempfile as tempfile
  262.             (garbage, path) = splittype(url)
  263.             if not path:
  264.                 pass
  265.             (garbage, path) = splithost('')
  266.             if not path:
  267.                 pass
  268.             (path, garbage) = splitquery('')
  269.             if not path:
  270.                 pass
  271.             (path, garbage) = splitattr('')
  272.             suffix = os.path.splitext(path)[1]
  273.             (fd, filename) = tempfile.mkstemp(suffix)
  274.             self._URLopener__tempfiles.append(filename)
  275.             tfp = os.fdopen(fd, 'wb')
  276.         result = (filename, headers)
  277.         if self.tempcache is not None:
  278.             self.tempcache[url] = result
  279.         
  280.         bs = 1024 * 8
  281.         size = -1
  282.         read = 0
  283.         blocknum = 0
  284.         if reporthook:
  285.             if 'content-length' in headers:
  286.                 size = int(headers['Content-Length'])
  287.             
  288.             reporthook(blocknum, bs, size)
  289.         
  290.         while None:
  291.             block = fp.read(bs)
  292.             if block == '':
  293.                 break
  294.             
  295.             read += len(block)
  296.             blocknum += 1
  297.             if reporthook:
  298.                 reporthook(blocknum, bs, size)
  299.                 continue
  300.         fp.close()
  301.         tfp.close()
  302.         del fp
  303.         del tfp
  304.         if size >= 0 and read < size:
  305.             raise ContentTooShortError('retrieval incomplete: got only %i out of %i bytes' % (read, size), result)
  306.         
  307.         return result
  308.  
  309.     
  310.     def open_http(self, url, data = None):
  311.         '''Use HTTP protocol.'''
  312.         import httplib as httplib
  313.         user_passwd = None
  314.         if isinstance(url, str):
  315.             (host, selector) = splithost(url)
  316.             if host:
  317.                 (user_passwd, host) = splituser(host)
  318.                 host = unquote(host)
  319.             
  320.             realhost = host
  321.         else:
  322.             (host, selector) = url
  323.             (urltype, rest) = splittype(selector)
  324.             url = rest
  325.             user_passwd = None
  326.             if urltype.lower() != 'http':
  327.                 realhost = None
  328.             else:
  329.                 (realhost, rest) = splithost(rest)
  330.                 if realhost:
  331.                     (user_passwd, realhost) = splituser(realhost)
  332.                 
  333.                 if user_passwd:
  334.                     selector = '%s://%s%s' % (urltype, realhost, rest)
  335.                 
  336.                 if proxy_bypass(realhost):
  337.                     host = realhost
  338.                 
  339.         if not host:
  340.             raise IOError, ('http error', 'no host given')
  341.         
  342.         if user_passwd:
  343.             import base64 as base64
  344.             auth = base64.encodestring(user_passwd).strip()
  345.         else:
  346.             auth = None
  347.         h = httplib.HTTP(host)
  348.         if data is not None:
  349.             h.putrequest('POST', selector)
  350.             h.putheader('Content-type', 'application/x-www-form-urlencoded')
  351.             h.putheader('Content-length', '%d' % len(data))
  352.         else:
  353.             h.putrequest('GET', selector)
  354.         if auth:
  355.             h.putheader('Authorization', 'Basic %s' % auth)
  356.         
  357.         if realhost:
  358.             h.putheader('Host', realhost)
  359.         
  360.         for args in self.addheaders:
  361.             h.putheader(*args)
  362.         
  363.         h.endheaders()
  364.         if data is not None:
  365.             h.send(data)
  366.         
  367.         (errcode, errmsg, headers) = h.getreply()
  368.         fp = h.getfile()
  369.         if errcode == 200:
  370.             return addinfourl(fp, headers, 'http:' + url)
  371.         elif data is None:
  372.             return self.http_error(url, fp, errcode, errmsg, headers)
  373.         else:
  374.             return self.http_error(url, fp, errcode, errmsg, headers, data)
  375.  
  376.     
  377.     def http_error(self, url, fp, errcode, errmsg, headers, data = None):
  378.         '''Handle http errors.
  379.         Derived class can override this, or provide specific handlers
  380.         named http_error_DDD where DDD is the 3-digit error code.'''
  381.         name = 'http_error_%d' % errcode
  382.         if hasattr(self, name):
  383.             method = getattr(self, name)
  384.             if data is None:
  385.                 result = method(url, fp, errcode, errmsg, headers)
  386.             else:
  387.                 result = method(url, fp, errcode, errmsg, headers, data)
  388.             if result:
  389.                 return result
  390.             
  391.         
  392.         return self.http_error_default(url, fp, errcode, errmsg, headers)
  393.  
  394.     
  395.     def http_error_default(self, url, fp, errcode, errmsg, headers):
  396.         '''Default error handler: close the connection and raise IOError.'''
  397.         void = fp.read()
  398.         fp.close()
  399.         raise IOError, ('http error', errcode, errmsg, headers)
  400.  
  401.     if hasattr(socket, 'ssl'):
  402.         
  403.         def open_https(self, url, data = None):
  404.             '''Use HTTPS protocol.'''
  405.             import httplib
  406.             user_passwd = None
  407.             if isinstance(url, str):
  408.                 (host, selector) = splithost(url)
  409.                 if host:
  410.                     (user_passwd, host) = splituser(host)
  411.                     host = unquote(host)
  412.                 
  413.                 realhost = host
  414.             else:
  415.                 (host, selector) = url
  416.                 (urltype, rest) = splittype(selector)
  417.                 url = rest
  418.                 user_passwd = None
  419.                 if urltype.lower() != 'https':
  420.                     realhost = None
  421.                 else:
  422.                     (realhost, rest) = splithost(rest)
  423.                     if realhost:
  424.                         (user_passwd, realhost) = splituser(realhost)
  425.                     
  426.                     if user_passwd:
  427.                         selector = '%s://%s%s' % (urltype, realhost, rest)
  428.                     
  429.             if not host:
  430.                 raise IOError, ('https error', 'no host given')
  431.             
  432.             if user_passwd:
  433.                 import base64
  434.                 auth = base64.encodestring(user_passwd).strip()
  435.             else:
  436.                 auth = None
  437.             h = httplib.HTTPS(host, 0, key_file = self.key_file, cert_file = self.cert_file)
  438.             if data is not None:
  439.                 h.putrequest('POST', selector)
  440.                 h.putheader('Content-type', 'application/x-www-form-urlencoded')
  441.                 h.putheader('Content-length', '%d' % len(data))
  442.             else:
  443.                 h.putrequest('GET', selector)
  444.             if auth:
  445.                 h.putheader('Authorization', 'Basic %s' % auth)
  446.             
  447.             if realhost:
  448.                 h.putheader('Host', realhost)
  449.             
  450.             for args in self.addheaders:
  451.                 h.putheader(*args)
  452.             
  453.             h.endheaders()
  454.             if data is not None:
  455.                 h.send(data)
  456.             
  457.             (errcode, errmsg, headers) = h.getreply()
  458.             fp = h.getfile()
  459.             if errcode == 200:
  460.                 return addinfourl(fp, headers, 'https:' + url)
  461.             elif data is None:
  462.                 return self.http_error(url, fp, errcode, errmsg, headers)
  463.             else:
  464.                 return self.http_error(url, fp, errcode, errmsg, headers, data)
  465.  
  466.     
  467.     
  468.     def open_gopher(self, url):
  469.         '''Use Gopher protocol.'''
  470.         import gopherlib as gopherlib
  471.         (host, selector) = splithost(url)
  472.         if not host:
  473.             raise IOError, ('gopher error', 'no host given')
  474.         
  475.         host = unquote(host)
  476.         (type, selector) = splitgophertype(selector)
  477.         (selector, query) = splitquery(selector)
  478.         selector = unquote(selector)
  479.         if query:
  480.             query = unquote(query)
  481.             fp = gopherlib.send_query(selector, query, host)
  482.         else:
  483.             fp = gopherlib.send_selector(selector, host)
  484.         return addinfourl(fp, noheaders(), 'gopher:' + url)
  485.  
  486.     
  487.     def open_file(self, url):
  488.         '''Use local file or FTP depending on form of URL.'''
  489.         if url[:2] == '//' and url[2:3] != '/' and url[2:12].lower() != 'localhost/':
  490.             return self.open_ftp(url)
  491.         else:
  492.             return self.open_local_file(url)
  493.  
  494.     
  495.     def open_local_file(self, url):
  496.         '''Use local file.'''
  497.         import mimetypes as mimetypes
  498.         import mimetools as mimetools
  499.         import email.Utils as email
  500.         
  501.         try:
  502.             StringIO = StringIO
  503.             import cStringIO
  504.         except ImportError:
  505.             StringIO = StringIO
  506.             import StringIO
  507.  
  508.         (host, file) = splithost(url)
  509.         localname = url2pathname(file)
  510.         
  511.         try:
  512.             stats = os.stat(localname)
  513.         except OSError:
  514.             e = None
  515.             raise IOError(e.errno, e.strerror, e.filename)
  516.  
  517.         size = stats.st_size
  518.         modified = email.Utils.formatdate(stats.st_mtime, usegmt = True)
  519.         mtype = mimetypes.guess_type(url)[0]
  520.         if not mtype:
  521.             pass
  522.         headers = mimetools.Message(StringIO('Content-Type: %s\nContent-Length: %d\nLast-modified: %s\n' % ('text/plain', size, modified)))
  523.         if not host:
  524.             urlfile = file
  525.             if file[:1] == '/':
  526.                 urlfile = 'file://' + file
  527.             
  528.             return addinfourl(open(localname, 'rb'), headers, urlfile)
  529.         
  530.         (host, port) = splitport(host)
  531.         if not port and socket.gethostbyname(host) in (localhost(), thishost()):
  532.             urlfile = file
  533.             if file[:1] == '/':
  534.                 urlfile = 'file://' + file
  535.             
  536.             return addinfourl(open(localname, 'rb'), headers, urlfile)
  537.         
  538.         raise IOError, ('local file error', 'not on local host')
  539.  
  540.     
  541.     def open_ftp(self, url):
  542.         '''Use FTP protocol.'''
  543.         import mimetypes
  544.         import mimetools
  545.         
  546.         try:
  547.             StringIO = StringIO
  548.             import cStringIO
  549.         except ImportError:
  550.             StringIO = StringIO
  551.             import StringIO
  552.  
  553.         (host, path) = splithost(url)
  554.         if not host:
  555.             raise IOError, ('ftp error', 'no host given')
  556.         
  557.         (host, port) = splitport(host)
  558.         (user, host) = splituser(host)
  559.         if user:
  560.             (user, passwd) = splitpasswd(user)
  561.         else:
  562.             passwd = None
  563.         host = unquote(host)
  564.         if not user:
  565.             pass
  566.         user = unquote('')
  567.         if not passwd:
  568.             pass
  569.         passwd = unquote('')
  570.         host = socket.gethostbyname(host)
  571.         if not port:
  572.             import ftplib as ftplib
  573.             port = ftplib.FTP_PORT
  574.         else:
  575.             port = int(port)
  576.         (path, attrs) = splitattr(path)
  577.         path = unquote(path)
  578.         dirs = path.split('/')
  579.         dirs = dirs[:-1]
  580.         file = dirs[-1]
  581.         if dirs and not dirs[0]:
  582.             dirs = dirs[1:]
  583.         
  584.         if dirs and not dirs[0]:
  585.             dirs[0] = '/'
  586.         
  587.         key = (user, host, port, '/'.join(dirs))
  588.         if len(self.ftpcache) > MAXFTPCACHE:
  589.             for k in self.ftpcache.keys():
  590.                 if k != key:
  591.                     v = self.ftpcache[k]
  592.                     del self.ftpcache[k]
  593.                     v.close()
  594.                     continue
  595.             
  596.         
  597.         
  598.         try:
  599.             if key not in self.ftpcache:
  600.                 self.ftpcache[key] = ftpwrapper(user, passwd, host, port, dirs)
  601.             
  602.             if not file:
  603.                 type = 'D'
  604.             else:
  605.                 type = 'I'
  606.             for attr in attrs:
  607.                 (attr, value) = splitvalue(attr)
  608.                 if attr.lower() == 'type' and value in ('a', 'A', 'i', 'I', 'd', 'D'):
  609.                     type = value.upper()
  610.                     continue
  611.             
  612.             (fp, retrlen) = self.ftpcache[key].retrfile(file, type)
  613.             mtype = mimetypes.guess_type('ftp:' + url)[0]
  614.             headers = ''
  615.             if mtype:
  616.                 headers += 'Content-Type: %s\n' % mtype
  617.             
  618.             if retrlen is not None and retrlen >= 0:
  619.                 headers += 'Content-Length: %d\n' % retrlen
  620.             
  621.             headers = mimetools.Message(StringIO(headers))
  622.             return addinfourl(fp, headers, 'ftp:' + url)
  623.         except ftperrors():
  624.             msg = None
  625.             raise IOError, ('ftp error', msg), sys.exc_info()[2]
  626.  
  627.  
  628.     
  629.     def open_data(self, url, data = None):
  630.         '''Use "data" URL.'''
  631.         import mimetools
  632.         
  633.         try:
  634.             StringIO = StringIO
  635.             import cStringIO
  636.         except ImportError:
  637.             StringIO = StringIO
  638.             import StringIO
  639.  
  640.         
  641.         try:
  642.             (type, data) = url.split(',', 1)
  643.         except ValueError:
  644.             raise IOError, ('data error', 'bad data URL')
  645.  
  646.         if not type:
  647.             type = 'text/plain;charset=US-ASCII'
  648.         
  649.         semi = type.rfind(';')
  650.         if semi >= 0 and '=' not in type[semi:]:
  651.             encoding = type[semi + 1:]
  652.             type = type[:semi]
  653.         else:
  654.             encoding = ''
  655.         msg = []
  656.         msg.append('Date: %s' % time.strftime('%a, %d %b %Y %T GMT', time.gmtime(time.time())))
  657.         msg.append('Content-type: %s' % type)
  658.         if encoding == 'base64':
  659.             import base64
  660.             data = base64.decodestring(data)
  661.         else:
  662.             data = unquote(data)
  663.         msg.append('Content-length: %d' % len(data))
  664.         msg.append('')
  665.         msg.append(data)
  666.         msg = '\n'.join(msg)
  667.         f = StringIO(msg)
  668.         headers = mimetools.Message(f, 0)
  669.         f.fileno = None
  670.         return addinfourl(f, headers, url)
  671.  
  672.  
  673.  
  674. class FancyURLopener(URLopener):
  675.     '''Derived class with handlers for errors we can handle (perhaps).'''
  676.     
  677.     def __init__(self, *args, **kwargs):
  678.         URLopener.__init__(self, *args, **kwargs)
  679.         self.auth_cache = { }
  680.         self.tries = 0
  681.         self.maxtries = 10
  682.  
  683.     
  684.     def http_error_default(self, url, fp, errcode, errmsg, headers):
  685.         """Default error handling -- don't raise an exception."""
  686.         return addinfourl(fp, headers, 'http:' + url)
  687.  
  688.     
  689.     def http_error_302(self, url, fp, errcode, errmsg, headers, data = None):
  690.         '''Error 302 -- relocated (temporarily).'''
  691.         self.tries += 1
  692.         result = self.redirect_internal(url, fp, errcode, errmsg, headers, data)
  693.         self.tries = 0
  694.         return result
  695.  
  696.     
  697.     def redirect_internal(self, url, fp, errcode, errmsg, headers, data):
  698.         if 'location' in headers:
  699.             newurl = headers['location']
  700.         elif 'uri' in headers:
  701.             newurl = headers['uri']
  702.         else:
  703.             return None
  704.         void = fp.read()
  705.         fp.close()
  706.         newurl = basejoin(self.type + ':' + url, newurl)
  707.         return self.open(newurl)
  708.  
  709.     
  710.     def http_error_301(self, url, fp, errcode, errmsg, headers, data = None):
  711.         '''Error 301 -- also relocated (permanently).'''
  712.         return self.http_error_302(url, fp, errcode, errmsg, headers, data)
  713.  
  714.     
  715.     def http_error_303(self, url, fp, errcode, errmsg, headers, data = None):
  716.         '''Error 303 -- also relocated (essentially identical to 302).'''
  717.         return self.http_error_302(url, fp, errcode, errmsg, headers, data)
  718.  
  719.     
  720.     def http_error_307(self, url, fp, errcode, errmsg, headers, data = None):
  721.         '''Error 307 -- relocated, but turn POST into error.'''
  722.         if data is None:
  723.             return self.http_error_302(url, fp, errcode, errmsg, headers, data)
  724.         else:
  725.             return self.http_error_default(url, fp, errcode, errmsg, headers)
  726.  
  727.     
  728.     def http_error_401(self, url, fp, errcode, errmsg, headers, data = None):
  729.         '''Error 401 -- authentication required.
  730.         See this URL for a description of the basic authentication scheme:
  731.         http://www.ics.uci.edu/pub/ietf/http/draft-ietf-http-v10-spec-00.txt'''
  732.         if 'www-authenticate' not in headers:
  733.             URLopener.http_error_default(self, url, fp, errcode, errmsg, headers)
  734.         
  735.         stuff = headers['www-authenticate']
  736.         import re as re
  737.         match = re.match('[ \t]*([^ \t]+)[ \t]+realm="([^"]*)"', stuff)
  738.         if not match:
  739.             URLopener.http_error_default(self, url, fp, errcode, errmsg, headers)
  740.         
  741.         (scheme, realm) = match.groups()
  742.         if scheme.lower() != 'basic':
  743.             URLopener.http_error_default(self, url, fp, errcode, errmsg, headers)
  744.         
  745.         name = 'retry_' + self.type + '_basic_auth'
  746.         if data is None:
  747.             return getattr(self, name)(url, realm)
  748.         else:
  749.             return getattr(self, name)(url, realm, data)
  750.  
  751.     
  752.     def retry_http_basic_auth(self, url, realm, data = None):
  753.         (host, selector) = splithost(url)
  754.         i = host.find('@') + 1
  755.         host = host[i:]
  756.         (user, passwd) = self.get_user_passwd(host, realm, i)
  757.         if not user or passwd:
  758.             return None
  759.         
  760.         host = quote(user, safe = '') + ':' + quote(passwd, safe = '') + '@' + host
  761.         newurl = 'http://' + host + selector
  762.         if data is None:
  763.             return self.open(newurl)
  764.         else:
  765.             return self.open(newurl, data)
  766.  
  767.     
  768.     def retry_https_basic_auth(self, url, realm, data = None):
  769.         (host, selector) = splithost(url)
  770.         i = host.find('@') + 1
  771.         host = host[i:]
  772.         (user, passwd) = self.get_user_passwd(host, realm, i)
  773.         if not user or passwd:
  774.             return None
  775.         
  776.         host = quote(user, safe = '') + ':' + quote(passwd, safe = '') + '@' + host
  777.         newurl = '//' + host + selector
  778.         return self.open_https(newurl, data)
  779.  
  780.     
  781.     def get_user_passwd(self, host, realm, clear_cache = 0):
  782.         key = realm + '@' + host.lower()
  783.         if key in self.auth_cache:
  784.             if clear_cache:
  785.                 del self.auth_cache[key]
  786.             else:
  787.                 return self.auth_cache[key]
  788.         
  789.         (user, passwd) = self.prompt_user_passwd(host, realm)
  790.         if user or passwd:
  791.             self.auth_cache[key] = (user, passwd)
  792.         
  793.         return (user, passwd)
  794.  
  795.     
  796.     def prompt_user_passwd(self, host, realm):
  797.         '''Override this in a GUI environment!'''
  798.         import getpass as getpass
  799.         
  800.         try:
  801.             user = raw_input('Enter username for %s at %s: ' % (realm, host))
  802.             passwd = getpass.getpass('Enter password for %s in %s at %s: ' % (user, realm, host))
  803.             return (user, passwd)
  804.         except KeyboardInterrupt:
  805.             print 
  806.             return (None, None)
  807.  
  808.  
  809.  
  810. _localhost = None
  811.  
  812. def localhost():
  813.     """Return the IP address of the magic hostname 'localhost'."""
  814.     global _localhost
  815.     if _localhost is None:
  816.         _localhost = socket.gethostbyname('localhost')
  817.     
  818.     return _localhost
  819.  
  820. _thishost = None
  821.  
  822. def thishost():
  823.     '''Return the IP address of the current host.'''
  824.     global _thishost
  825.     if _thishost is None:
  826.         _thishost = socket.gethostbyname(socket.gethostname())
  827.     
  828.     return _thishost
  829.  
  830. _ftperrors = None
  831.  
  832. def ftperrors():
  833.     '''Return the set of errors raised by the FTP class.'''
  834.     global _ftperrors
  835.     if _ftperrors is None:
  836.         import ftplib
  837.         _ftperrors = ftplib.all_errors
  838.     
  839.     return _ftperrors
  840.  
  841. _noheaders = None
  842.  
  843. def noheaders():
  844.     '''Return an empty mimetools.Message object.'''
  845.     global _noheaders
  846.     if _noheaders is None:
  847.         import mimetools
  848.         
  849.         try:
  850.             StringIO = StringIO
  851.             import cStringIO
  852.         except ImportError:
  853.             StringIO = StringIO
  854.             import StringIO
  855.  
  856.         _noheaders = mimetools.Message(StringIO(), 0)
  857.         _noheaders.fp.close()
  858.     
  859.     return _noheaders
  860.  
  861.  
  862. class ftpwrapper:
  863.     '''Class used by open_ftp() for cache of open FTP connections.'''
  864.     
  865.     def __init__(self, user, passwd, host, port, dirs):
  866.         self.user = user
  867.         self.passwd = passwd
  868.         self.host = host
  869.         self.port = port
  870.         self.dirs = dirs
  871.         self.init()
  872.  
  873.     
  874.     def init(self):
  875.         import ftplib
  876.         self.busy = 0
  877.         self.ftp = ftplib.FTP()
  878.         self.ftp.connect(self.host, self.port)
  879.         self.ftp.login(self.user, self.passwd)
  880.         for dir in self.dirs:
  881.             self.ftp.cwd(dir)
  882.         
  883.  
  884.     
  885.     def retrfile(self, file, type):
  886.         import ftplib
  887.         self.endtransfer()
  888.         if type in ('d', 'D'):
  889.             cmd = 'TYPE A'
  890.             isdir = 1
  891.         else:
  892.             cmd = 'TYPE ' + type
  893.             isdir = 0
  894.         
  895.         try:
  896.             self.ftp.voidcmd(cmd)
  897.         except ftplib.all_errors:
  898.             self.init()
  899.             self.ftp.voidcmd(cmd)
  900.  
  901.         conn = None
  902.         if file and not isdir:
  903.             
  904.             try:
  905.                 self.ftp.nlst(file)
  906.             except ftplib.error_perm:
  907.                 reason = None
  908.                 raise IOError, ('ftp error', reason), sys.exc_info()[2]
  909.  
  910.             self.ftp.voidcmd(cmd)
  911.             
  912.             try:
  913.                 cmd = 'RETR ' + file
  914.                 conn = self.ftp.ntransfercmd(cmd)
  915.             except ftplib.error_perm:
  916.                 reason = None
  917.                 if str(reason)[:3] != '550':
  918.                     raise IOError, ('ftp error', reason), sys.exc_info()[2]
  919.                 
  920.             except:
  921.                 str(reason)[:3] != '550'
  922.             
  923.  
  924.         None<EXCEPTION MATCH>ftplib.error_perm
  925.         if not conn:
  926.             self.ftp.voidcmd('TYPE A')
  927.             if file:
  928.                 cmd = 'LIST ' + file
  929.             else:
  930.                 cmd = 'LIST'
  931.             conn = self.ftp.ntransfercmd(cmd)
  932.         
  933.         self.busy = 1
  934.         return (addclosehook(conn[0].makefile('rb'), self.endtransfer), conn[1])
  935.  
  936.     
  937.     def endtransfer(self):
  938.         if not self.busy:
  939.             return None
  940.         
  941.         self.busy = 0
  942.         
  943.         try:
  944.             self.ftp.voidresp()
  945.         except ftperrors():
  946.             pass
  947.  
  948.  
  949.     
  950.     def close(self):
  951.         self.endtransfer()
  952.         
  953.         try:
  954.             self.ftp.close()
  955.         except ftperrors():
  956.             pass
  957.  
  958.  
  959.  
  960.  
  961. class addbase:
  962.     '''Base class for addinfo and addclosehook.'''
  963.     
  964.     def __init__(self, fp):
  965.         self.fp = fp
  966.         self.read = self.fp.read
  967.         self.readline = self.fp.readline
  968.         if hasattr(self.fp, 'readlines'):
  969.             self.readlines = self.fp.readlines
  970.         
  971.         if hasattr(self.fp, 'fileno'):
  972.             self.fileno = self.fp.fileno
  973.         
  974.         if hasattr(self.fp, '__iter__'):
  975.             self.__iter__ = self.fp.__iter__
  976.             if hasattr(self.fp, 'next'):
  977.                 self.next = self.fp.next
  978.             
  979.         
  980.  
  981.     
  982.     def __repr__(self):
  983.         return '<%s at %r whose fp = %r>' % (self.__class__.__name__, id(self), self.fp)
  984.  
  985.     
  986.     def close(self):
  987.         self.read = None
  988.         self.readline = None
  989.         self.readlines = None
  990.         self.fileno = None
  991.         if self.fp:
  992.             self.fp.close()
  993.         
  994.         self.fp = None
  995.  
  996.  
  997.  
  998. class addclosehook(addbase):
  999.     '''Class to add a close hook to an open file.'''
  1000.     
  1001.     def __init__(self, fp, closehook, *hookargs):
  1002.         addbase.__init__(self, fp)
  1003.         self.closehook = closehook
  1004.         self.hookargs = hookargs
  1005.  
  1006.     
  1007.     def close(self):
  1008.         addbase.close(self)
  1009.         if self.closehook:
  1010.             self.closehook(*self.hookargs)
  1011.             self.closehook = None
  1012.             self.hookargs = None
  1013.         
  1014.  
  1015.  
  1016.  
  1017. class addinfo(addbase):
  1018.     '''class to add an info() method to an open file.'''
  1019.     
  1020.     def __init__(self, fp, headers):
  1021.         addbase.__init__(self, fp)
  1022.         self.headers = headers
  1023.  
  1024.     
  1025.     def info(self):
  1026.         return self.headers
  1027.  
  1028.  
  1029.  
  1030. class addinfourl(addbase):
  1031.     '''class to add info() and geturl() methods to an open file.'''
  1032.     
  1033.     def __init__(self, fp, headers, url):
  1034.         addbase.__init__(self, fp)
  1035.         self.headers = headers
  1036.         self.url = url
  1037.  
  1038.     
  1039.     def info(self):
  1040.         return self.headers
  1041.  
  1042.     
  1043.     def geturl(self):
  1044.         return self.url
  1045.  
  1046.  
  1047.  
  1048. try:
  1049.     unicode
  1050. except NameError:
  1051.     
  1052.     def _is_unicode(x):
  1053.         return 0
  1054.  
  1055.  
  1056.  
  1057. def _is_unicode(x):
  1058.     return isinstance(x, unicode)
  1059.  
  1060.  
  1061. def toBytes(url):
  1062.     '''toBytes(u"URL") --> \'URL\'.'''
  1063.     if _is_unicode(url):
  1064.         
  1065.         try:
  1066.             url = url.encode('ASCII')
  1067.         except UnicodeError:
  1068.             raise UnicodeError('URL ' + repr(url) + ' contains non-ASCII characters')
  1069.         except:
  1070.             None<EXCEPTION MATCH>UnicodeError
  1071.         
  1072.  
  1073.     None<EXCEPTION MATCH>UnicodeError
  1074.     return url
  1075.  
  1076.  
  1077. def unwrap(url):
  1078.     """unwrap('<URL:type://host/path>') --> 'type://host/path'."""
  1079.     url = url.strip()
  1080.     if url[:1] == '<' and url[-1:] == '>':
  1081.         url = url[1:-1].strip()
  1082.     
  1083.     if url[:4] == 'URL:':
  1084.         url = url[4:].strip()
  1085.     
  1086.     return url
  1087.  
  1088. _typeprog = None
  1089.  
  1090. def splittype(url):
  1091.     """splittype('type:opaquestring') --> 'type', 'opaquestring'."""
  1092.     global _typeprog
  1093.     if _typeprog is None:
  1094.         import re
  1095.         _typeprog = re.compile('^([^/:]+):')
  1096.     
  1097.     match = _typeprog.match(url)
  1098.     if match:
  1099.         scheme = match.group(1)
  1100.         return (scheme.lower(), url[len(scheme) + 1:])
  1101.     
  1102.     return (None, url)
  1103.  
  1104. _hostprog = None
  1105.  
  1106. def splithost(url):
  1107.     """splithost('//host[:port]/path') --> 'host[:port]', '/path'."""
  1108.     global _hostprog
  1109.     if _hostprog is None:
  1110.         import re
  1111.         _hostprog = re.compile('^//([^/]*)(.*)$')
  1112.     
  1113.     match = _hostprog.match(url)
  1114.     if match:
  1115.         return match.group(1, 2)
  1116.     
  1117.     return (None, url)
  1118.  
  1119. _userprog = None
  1120.  
  1121. def splituser(host):
  1122.     """splituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'."""
  1123.     global _userprog
  1124.     if _userprog is None:
  1125.         import re
  1126.         _userprog = re.compile('^(.*)@(.*)$')
  1127.     
  1128.     match = _userprog.match(host)
  1129.     if match:
  1130.         return map(unquote, match.group(1, 2))
  1131.     
  1132.     return (None, host)
  1133.  
  1134. _passwdprog = None
  1135.  
  1136. def splitpasswd(user):
  1137.     """splitpasswd('user:passwd') -> 'user', 'passwd'."""
  1138.     global _passwdprog
  1139.     if _passwdprog is None:
  1140.         import re
  1141.         _passwdprog = re.compile('^([^:]*):(.*)$')
  1142.     
  1143.     match = _passwdprog.match(user)
  1144.     if match:
  1145.         return match.group(1, 2)
  1146.     
  1147.     return (user, None)
  1148.  
  1149. _portprog = None
  1150.  
  1151. def splitport(host):
  1152.     """splitport('host:port') --> 'host', 'port'."""
  1153.     global _portprog
  1154.     if _portprog is None:
  1155.         import re
  1156.         _portprog = re.compile('^(.*):([0-9]+)$')
  1157.     
  1158.     match = _portprog.match(host)
  1159.     if match:
  1160.         return match.group(1, 2)
  1161.     
  1162.     return (host, None)
  1163.  
  1164. _nportprog = None
  1165.  
  1166. def splitnport(host, defport = -1):
  1167.     """Split host and port, returning numeric port.
  1168.     Return given default port if no ':' found; defaults to -1.
  1169.     Return numerical port if a valid number are found after ':'.
  1170.     Return None if ':' but not a valid number."""
  1171.     global _nportprog
  1172.     if _nportprog is None:
  1173.         import re
  1174.         _nportprog = re.compile('^(.*):(.*)$')
  1175.     
  1176.     match = _nportprog.match(host)
  1177.     if match:
  1178.         (host, port) = match.group(1, 2)
  1179.         
  1180.         try:
  1181.             if not port:
  1182.                 raise ValueError, 'no digits'
  1183.             
  1184.             nport = int(port)
  1185.         except ValueError:
  1186.             nport = None
  1187.  
  1188.         return (host, nport)
  1189.     
  1190.     return (host, defport)
  1191.  
  1192. _queryprog = None
  1193.  
  1194. def splitquery(url):
  1195.     """splitquery('/path?query') --> '/path', 'query'."""
  1196.     global _queryprog
  1197.     if _queryprog is None:
  1198.         import re
  1199.         _queryprog = re.compile('^(.*)\\?([^?]*)$')
  1200.     
  1201.     match = _queryprog.match(url)
  1202.     if match:
  1203.         return match.group(1, 2)
  1204.     
  1205.     return (url, None)
  1206.  
  1207. _tagprog = None
  1208.  
  1209. def splittag(url):
  1210.     """splittag('/path#tag') --> '/path', 'tag'."""
  1211.     global _tagprog
  1212.     if _tagprog is None:
  1213.         import re
  1214.         _tagprog = re.compile('^(.*)#([^#]*)$')
  1215.     
  1216.     match = _tagprog.match(url)
  1217.     if match:
  1218.         return match.group(1, 2)
  1219.     
  1220.     return (url, None)
  1221.  
  1222.  
  1223. def splitattr(url):
  1224.     """splitattr('/path;attr1=value1;attr2=value2;...') ->
  1225.         '/path', ['attr1=value1', 'attr2=value2', ...]."""
  1226.     words = url.split(';')
  1227.     return (words[0], words[1:])
  1228.  
  1229. _valueprog = None
  1230.  
  1231. def splitvalue(attr):
  1232.     """splitvalue('attr=value') --> 'attr', 'value'."""
  1233.     global _valueprog
  1234.     if _valueprog is None:
  1235.         import re
  1236.         _valueprog = re.compile('^([^=]*)=(.*)$')
  1237.     
  1238.     match = _valueprog.match(attr)
  1239.     if match:
  1240.         return match.group(1, 2)
  1241.     
  1242.     return (attr, None)
  1243.  
  1244.  
  1245. def splitgophertype(selector):
  1246.     """splitgophertype('/Xselector') --> 'X', 'selector'."""
  1247.     if selector[:1] == '/' and selector[1:2]:
  1248.         return (selector[1], selector[2:])
  1249.     
  1250.     return (None, selector)
  1251.  
  1252. _hextochr = dict((lambda [outmost-iterable]: for i in [outmost-iterable]:
  1253. ('%02x' % i, chr(i)))(range(256)))
  1254. _hextochr.update((lambda [outmost-iterable]: for i in [outmost-iterable]:
  1255. ('%02X' % i, chr(i)))(range(256)))
  1256.  
  1257. def unquote(s):
  1258.     """unquote('abc%20def') -> 'abc def'."""
  1259.     res = s.split('%')
  1260.     for i in xrange(1, len(res)):
  1261.         item = res[i]
  1262.         
  1263.         try:
  1264.             res[i] = _hextochr[item[:2]] + item[2:]
  1265.         continue
  1266.         except KeyError:
  1267.             res[i] = '%' + item
  1268.             continue
  1269.         
  1270.  
  1271.     
  1272.     return ''.join(res)
  1273.  
  1274.  
  1275. def unquote_plus(s):
  1276.     """unquote('%7e/abc+def') -> '~/abc def'"""
  1277.     s = s.replace('+', ' ')
  1278.     return unquote(s)
  1279.  
  1280. always_safe = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_.-'
  1281. _safemaps = { }
  1282.  
  1283. def quote(s, safe = '/'):
  1284.     '''quote(\'abc def\') -> \'abc%20def\'
  1285.  
  1286.     Each part of a URL, e.g. the path info, the query, etc., has a
  1287.     different set of reserved characters that must be quoted.
  1288.  
  1289.     RFC 2396 Uniform Resource Identifiers (URI): Generic Syntax lists
  1290.     the following reserved characters.
  1291.  
  1292.     reserved    = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
  1293.                   "$" | ","
  1294.  
  1295.     Each of these characters is reserved in some component of a URL,
  1296.     but not necessarily in all of them.
  1297.  
  1298.     By default, the quote function is intended for quoting the path
  1299.     section of a URL.  Thus, it will not encode \'/\'.  This character
  1300.     is reserved, but in typical usage the quote function is being
  1301.     called on a path where the existing slash characters are used as
  1302.     reserved characters.
  1303.     '''
  1304.     cachekey = (safe, always_safe)
  1305.     
  1306.     try:
  1307.         safe_map = _safemaps[cachekey]
  1308.     except KeyError:
  1309.         safe += always_safe
  1310.         safe_map = { }
  1311.         for i in range(256):
  1312.             c = chr(i)
  1313.             if not c in safe or c:
  1314.                 pass
  1315.             safe_map[c] = '%%%02X' % i
  1316.         
  1317.         _safemaps[cachekey] = safe_map
  1318.  
  1319.     res = map(safe_map.__getitem__, s)
  1320.     return ''.join(res)
  1321.  
  1322.  
  1323. def quote_plus(s, safe = ''):
  1324.     """Quote the query fragment of a URL; replacing ' ' with '+'"""
  1325.     if ' ' in s:
  1326.         s = quote(s, safe + ' ')
  1327.         return s.replace(' ', '+')
  1328.     
  1329.     return quote(s, safe)
  1330.  
  1331.  
  1332. def urlencode(query, doseq = 0):
  1333.     '''Encode a sequence of two-element tuples or dictionary into a URL query string.
  1334.  
  1335.     If any values in the query arg are sequences and doseq is true, each
  1336.     sequence element is converted to a separate parameter.
  1337.  
  1338.     If the query arg is a sequence of two-element tuples, the order of the
  1339.     parameters in the output will match the order of parameters in the
  1340.     input.
  1341.     '''
  1342.     if hasattr(query, 'items'):
  1343.         query = query.items()
  1344.     else:
  1345.         
  1346.         try:
  1347.             if len(query) and not isinstance(query[0], tuple):
  1348.                 raise TypeError
  1349.         except TypeError:
  1350.             (ty, va, tb) = sys.exc_info()
  1351.             raise TypeError, 'not a valid non-string sequence or mapping object', tb
  1352.  
  1353.     l = []
  1354.     if not doseq:
  1355.         for k, v in query:
  1356.             k = quote_plus(str(k))
  1357.             v = quote_plus(str(v))
  1358.             l.append(k + '=' + v)
  1359.         
  1360.     else:
  1361.         for k, v in query:
  1362.             k = quote_plus(str(k))
  1363.             if isinstance(v, str):
  1364.                 v = quote_plus(v)
  1365.                 l.append(k + '=' + v)
  1366.                 continue
  1367.             if _is_unicode(v):
  1368.                 v = quote_plus(v.encode('ASCII', 'replace'))
  1369.                 l.append(k + '=' + v)
  1370.                 continue
  1371.             
  1372.             try:
  1373.                 x = len(v)
  1374.             except TypeError:
  1375.                 v = quote_plus(str(v))
  1376.                 l.append(k + '=' + v)
  1377.                 continue
  1378.  
  1379.             for elt in v:
  1380.                 l.append(k + '=' + quote_plus(str(elt)))
  1381.             
  1382.         
  1383.     return '&'.join(l)
  1384.  
  1385.  
  1386. def getproxies_environment():
  1387.     '''Return a dictionary of scheme -> proxy server URL mappings.
  1388.  
  1389.     Scan the environment for variables named <scheme>_proxy;
  1390.     this seems to be the standard convention.  If you need a
  1391.     different way, you can pass a proxies dictionary to the
  1392.     [Fancy]URLopener constructor.
  1393.  
  1394.     '''
  1395.     proxies = { }
  1396.     for name, value in os.environ.items():
  1397.         name = name.lower()
  1398.         if value and name[-6:] == '_proxy':
  1399.             proxies[name[:-6]] = value
  1400.             continue
  1401.     
  1402.     return proxies
  1403.  
  1404. if sys.platform == 'darwin':
  1405.     
  1406.     def getproxies_internetconfig():
  1407.         '''Return a dictionary of scheme -> proxy server URL mappings.
  1408.  
  1409.         By convention the mac uses Internet Config to store
  1410.         proxies.  An HTTP proxy, for instance, is stored under
  1411.         the HttpProxy key.
  1412.  
  1413.         '''
  1414.         
  1415.         try:
  1416.             import ic as ic
  1417.         except ImportError:
  1418.             return { }
  1419.  
  1420.         
  1421.         try:
  1422.             config = ic.IC()
  1423.         except ic.error:
  1424.             return { }
  1425.  
  1426.         proxies = { }
  1427.         if 'UseHTTPProxy' in config and config['UseHTTPProxy']:
  1428.             
  1429.             try:
  1430.                 value = config['HTTPProxyHost']
  1431.             except ic.error:
  1432.                 pass
  1433.  
  1434.             proxies['http'] = 'http://%s' % value
  1435.         
  1436.         return proxies
  1437.  
  1438.     
  1439.     def proxy_bypass(x):
  1440.         return 0
  1441.  
  1442.     
  1443.     def getproxies():
  1444.         if not getproxies_environment():
  1445.             pass
  1446.         return getproxies_internetconfig()
  1447.  
  1448. elif os.name == 'nt':
  1449.     
  1450.     def getproxies_registry():
  1451.         '''Return a dictionary of scheme -> proxy server URL mappings.
  1452.  
  1453.         Win32 uses the registry to store proxies.
  1454.  
  1455.         '''
  1456.         proxies = { }
  1457.         
  1458.         try:
  1459.             import _winreg as _winreg
  1460.         except ImportError:
  1461.             return proxies
  1462.  
  1463.         
  1464.         try:
  1465.             internetSettings = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, 'Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings')
  1466.             proxyEnable = _winreg.QueryValueEx(internetSettings, 'ProxyEnable')[0]
  1467.             if proxyEnable:
  1468.                 proxyServer = str(_winreg.QueryValueEx(internetSettings, 'ProxyServer')[0])
  1469.                 if '=' in proxyServer:
  1470.                     for p in proxyServer.split(';'):
  1471.                         (protocol, address) = p.split('=', 1)
  1472.                         import re
  1473.                         if not re.match('^([^/:]+)://', address):
  1474.                             address = '%s://%s' % (protocol, address)
  1475.                         
  1476.                         proxies[protocol] = address
  1477.                     
  1478.                 elif proxyServer[:5] == 'http:':
  1479.                     proxies['http'] = proxyServer
  1480.                 else:
  1481.                     proxies['http'] = 'http://%s' % proxyServer
  1482.                     proxies['ftp'] = 'ftp://%s' % proxyServer
  1483.             
  1484.             internetSettings.Close()
  1485.         except (WindowsError, ValueError, TypeError):
  1486.             pass
  1487.  
  1488.         return proxies
  1489.  
  1490.     
  1491.     def getproxies():
  1492.         '''Return a dictionary of scheme -> proxy server URL mappings.
  1493.  
  1494.         Returns settings gathered from the environment, if specified,
  1495.         or the registry.
  1496.  
  1497.         '''
  1498.         if not getproxies_environment():
  1499.             pass
  1500.         return getproxies_registry()
  1501.  
  1502.     
  1503.     def proxy_bypass(host):
  1504.         
  1505.         try:
  1506.             import _winreg
  1507.             import re
  1508.         except ImportError:
  1509.             return 0
  1510.  
  1511.         
  1512.         try:
  1513.             internetSettings = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, 'Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings')
  1514.             proxyEnable = _winreg.QueryValueEx(internetSettings, 'ProxyEnable')[0]
  1515.             proxyOverride = str(_winreg.QueryValueEx(internetSettings, 'ProxyOverride')[0])
  1516.         except WindowsError:
  1517.             return 0
  1518.  
  1519.         if not proxyEnable or not proxyOverride:
  1520.             return 0
  1521.         
  1522.         host = [
  1523.             host]
  1524.         
  1525.         try:
  1526.             addr = socket.gethostbyname(host[0])
  1527.             if addr != host:
  1528.                 host.append(addr)
  1529.         except socket.error:
  1530.             pass
  1531.  
  1532.         proxyOverride = proxyOverride.split(';')
  1533.         i = 0
  1534.         while i < len(proxyOverride):
  1535.             if proxyOverride[i] == '<local>':
  1536.                 proxyOverride[i:i + 1] = [
  1537.                     'localhost',
  1538.                     '127.0.0.1',
  1539.                     socket.gethostname(),
  1540.                     socket.gethostbyname(socket.gethostname())]
  1541.             
  1542.             i += 1
  1543.         for test in proxyOverride:
  1544.             test = test.replace('.', '\\.')
  1545.             test = test.replace('*', '.*')
  1546.             test = test.replace('?', '.')
  1547.             for val in host:
  1548.                 if re.match(test, val, re.I):
  1549.                     return 1
  1550.                     continue
  1551.             
  1552.         
  1553.         return 0
  1554.  
  1555. else:
  1556.     getproxies = getproxies_environment
  1557.     
  1558.     def proxy_bypass(host):
  1559.         return 0
  1560.  
  1561.  
  1562. def test1():
  1563.     s = ''
  1564.     for i in range(256):
  1565.         s = s + chr(i)
  1566.     
  1567.     s = s * 4
  1568.     t0 = time.time()
  1569.     qs = quote(s)
  1570.     uqs = unquote(qs)
  1571.     t1 = time.time()
  1572.     if uqs != s:
  1573.         print 'Wrong!'
  1574.     
  1575.     print repr(s)
  1576.     print repr(qs)
  1577.     print repr(uqs)
  1578.     print round(t1 - t0, 3), 'sec'
  1579.  
  1580.  
  1581. def reporthook(blocknum, blocksize, totalsize):
  1582.     print 'Block number: %d, Block size: %d, Total size: %d' % (blocknum, blocksize, totalsize)
  1583.  
  1584.  
  1585. def test(args = []):
  1586.     if not args:
  1587.         args = [
  1588.             '/etc/passwd',
  1589.             'file:/etc/passwd',
  1590.             'file://localhost/etc/passwd',
  1591.             'ftp://ftp.python.org/pub/python/README',
  1592.             'http://www.python.org/index.html']
  1593.         if hasattr(URLopener, 'open_https'):
  1594.             args.append('https://synergy.as.cmu.edu/~geek/')
  1595.         
  1596.     
  1597.     
  1598.     try:
  1599.         for url in args:
  1600.             print '-' * 10, url, '-' * 10
  1601.             (fn, h) = urlretrieve(url, None, reporthook)
  1602.             print fn
  1603.             if h:
  1604.                 print '======'
  1605.                 for k in h.keys():
  1606.                     print k + ':', h[k]
  1607.                 
  1608.                 print '======'
  1609.             
  1610.             fp = open(fn, 'rb')
  1611.             data = fp.read()
  1612.             del fp
  1613.             if '\r' in data:
  1614.                 table = string.maketrans('', '')
  1615.                 data = data.translate(table, '\r')
  1616.             
  1617.             print data
  1618.             (fn, h) = (None, None)
  1619.         
  1620.         print '-' * 40
  1621.     finally:
  1622.         urlcleanup()
  1623.  
  1624.  
  1625.  
  1626. def main():
  1627.     import getopt as getopt
  1628.     import sys
  1629.     
  1630.     try:
  1631.         (opts, args) = getopt.getopt(sys.argv[1:], 'th')
  1632.     except getopt.error:
  1633.         msg = None
  1634.         print msg
  1635.         print 'Use -h for help'
  1636.         return None
  1637.  
  1638.     t = 0
  1639.     for o, a in opts:
  1640.         if o == '-t':
  1641.             t = t + 1
  1642.         
  1643.         if o == '-h':
  1644.             print 'Usage: python urllib.py [-t] [url ...]'
  1645.             print '-t runs self-test;', 'otherwise, contents of urls are printed'
  1646.             return None
  1647.             continue
  1648.     
  1649.     if t:
  1650.         if t > 1:
  1651.             test1()
  1652.         
  1653.         test(args)
  1654.     elif not args:
  1655.         print 'Use -h for help'
  1656.     
  1657.     for url in args:
  1658.         print urlopen(url).read(),
  1659.     
  1660.  
  1661. if __name__ == '__main__':
  1662.     main()
  1663.  
  1664.